home *** CD-ROM | disk | FTP | other *** search
/ Almathera Ten Pack 3: CDPD 3 / Almathera Ten on Ten - Disc 3: CDPD3.iso / fish / 726-750 / 744 / fo2 / sources_fo2 / routinestd.c < prev    next >
C/C++ Source or Header  |  1995-03-18  |  4KB  |  150 lines
  1.                     /*                                           */
  2.                     /* Sous Prog pour utilisation du trackdisk */
  3.                     /*                                           */
  4.  
  5. #include "RoutinesTD.h"
  6.  
  7. #define Prototype extern
  8. #define ON 1L
  9. #define OFF 0L
  10. #define R CMD_READ
  11. #define W CMD_WRITE
  12. #define Actual[drive] ((*DiskReq[drive]).io_Actual)
  13.  
  14.  
  15. struct IOStdReq *DiskReq[4]={0,0,0,0};
  16. struct IOStdReq *A;
  17. struct MsgPort  *DiskPort[4]={0,0,0,0};
  18.  
  19. Prototype BYTE OpenTD(LONG drive);
  20. Prototype BYTE CMDonD(ULONG drive,UWORD Command,UBYTE Flags,ULONG Length,APTR Data,ULONG Offset);
  21. Prototype BYTE Read_WriteB(UWORD CMD,ULONG drive,APTR buffer,ULONG Bloc);
  22. Prototype BYTE Read_WriteT(UWORD CMD,ULONG drive,APTR buffer,ULONG Track);
  23. Prototype BYTE Read_WriteC(UWORD CMD,ULONG drive,APTR buffer,ULONG Cyl);
  24. Prototype BYTE MtrOn(LONG drive);
  25. Prototype BYTE MtrOff(LONG drive);
  26. Prototype void CloseaTD(LONG drive);
  27. Prototype void CloseTD();
  28. Prototype VOID DiskBUSY(UBYTE *drive,LONG onflag);
  29. Prototype ULONG isInserted(ULONG drive);
  30. Prototype ULONG isProtected(LONG drive);
  31.  
  32. Prototype struct IOStdReq *DiskReq[4];
  33.  
  34.  
  35. BYTE OpenTD(LONG drive)
  36. {
  37.     DiskPort[drive] =(struct MsgPort *)CreatePort(0L,0L);
  38.     DiskReq[drive] =(struct IOStdReq *)CreateStdIO(DiskPort[drive]);
  39.     if (!OpenDevice(TD_NAME,(ULONG)drive,(struct IORequest *)DiskReq[drive],0UL)) return(TRUE);
  40.         else
  41.     {
  42.         DeleteStdIO (DiskReq[drive]);
  43.         DeletePort    (DiskPort[drive]);
  44.         DiskReq[drive]=0;
  45.         DiskPort[drive]=0;
  46.     }
  47.         return(FALSE);
  48. }
  49.  
  50. BYTE CMDonD(ULONG drive,UWORD Command,UBYTE Flags,ULONG Length,APTR Data,ULONG Offset)
  51. {
  52.     A=DiskReq[drive];
  53.     (*A).io_Command = Command;
  54.     (*A).io_Flags = Flags;
  55.     (*A).io_Length = Length;
  56.     (*A).io_Data = Data;
  57.     (*A).io_Offset = Offset;
  58.     
  59.     DoIO((struct IORequest *)DiskReq[drive]);
  60.     return(    (*A).io_Error );
  61. }
  62.  
  63. BYTE Read_WriteB(UWORD CMD,ULONG drive,APTR buffer,ULONG Bloc)
  64. {
  65.     return (CMDonD(drive,CMD,0,TD_SECTOR,buffer,Bloc * TD_SECTOR));
  66. }
  67.  
  68. BYTE Read_WriteT(UWORD CMD,ULONG drive,APTR buffer,ULONG Track)
  69. {
  70.     return (CMDonD(drive,CMD,0,11 * TD_SECTOR,buffer,Track * 11 * TD_SECTOR));
  71. }
  72.  
  73. BYTE Read_WriteC(UWORD CMD,ULONG drive,APTR buffer,ULONG Cyl)
  74. {
  75.     return(CMDonD(drive,CMD,0,22 * TD_SECTOR,buffer,Cyl * 22 * TD_SECTOR));
  76. } 
  77.  
  78. BYTE MtrOn(LONG drive)
  79. {
  80.     return(CMDonD(drive,TD_MOTOR,0L,1L,0L,0L));
  81. }
  82.  
  83. BYTE MtrOff(LONG drive)
  84. {
  85.     return(CMDonD(drive,TD_MOTOR,0L,0L,0L,0L));
  86. }
  87.  
  88. void CloseaTD(LONG drive)
  89. {
  90.     if (DiskReq[drive])
  91.     {
  92.         A=DiskReq[drive];
  93.         CloseDevice((struct IORequest *)A);
  94.         DeleteStdIO (A);
  95.         DeletePort  (DiskPort[drive]);
  96.         DiskReq[drive]=NULL;
  97.         DiskPort[drive]=NULL;
  98.     }
  99. }
  100.  
  101. void CloseTD()
  102. {
  103. LONG  drive;
  104.     for (drive=0;drive<4;drive++) 
  105.     {
  106.         if (DiskReq[drive]) MtrOff(drive);
  107.         CloseaTD(drive);
  108.     }
  109. }
  110.  
  111. VOID DiskBUSY(UBYTE *drive,LONG onflag)
  112. {
  113. struct StandardPacket     *pk;
  114. struct Process            *tsk;
  115.  
  116.     tsk=(struct Process *)FindTask(NULL);
  117.     if (pk=(APTR)AllocMem (sizeof(struct StandardPacket), MEMF_PUBLIC|MEMF_CLEAR))
  118.     {
  119.         pk->sp_Msg.mn_Node.ln_Name=(UBYTE *)&(pk->sp_Pkt);
  120.  
  121.         pk->sp_Pkt.dp_Link=&(pk->sp_Msg);
  122.         pk->sp_Pkt.dp_Port=&(tsk->pr_MsgPort);
  123.         pk->sp_Pkt.dp_Type=ACTION_INHIBIT;
  124.         pk->sp_Pkt.dp_Arg1=(onflag ? -1L : 0L);
  125.  
  126.         PutMsg(DeviceProc(drive),(struct Message*)pk);
  127.         WaitPort(&(tsk->pr_MsgPort));
  128.         GetMsg(&(tsk->pr_MsgPort));
  129.         FreeMem(pk,(long)sizeof(*pk));
  130.     }
  131.  
  132. }    
  133.  
  134. /* return -1 if out , 0 if in */
  135. ULONG isInserted(ULONG drive)
  136. {
  137.     if (DiskReq[drive]) {
  138.     CMDonD(drive,TD_CHANGESTATE,0,0,0,0);
  139.     return((*DiskReq[drive]).io_Actual); }
  140.     else return(-1);
  141. }
  142.  
  143. ULONG isProtected(LONG drive)
  144. {
  145.     if (DiskReq[drive]) {
  146.     CMDonD(drive,TD_PROTSTATUS,0,0,0,0);
  147.     return((*DiskReq[drive]).io_Actual);}
  148.     else return(-1);
  149. }
  150.